if (!dojo._hasResource["dojo.date.locale"]) { //_hasResource checks added by build. Do not use _hasResource directly in your code.
    dojo._hasResource["dojo.date.locale"] = true;
    dojo.provide("dojo.date.locale");

    // Localization methods for Date.   Honor local customs using locale-dependent dojo.cldr data.

    dojo.require("dojo.date");
    dojo.require("dojo.cldr.supplemental");
    dojo.require("dojo.regexp");
    dojo.require("dojo.string");
    dojo.require("dojo.i18n");

    // Load the bundles containing localization information for
    // names and formats
    dojo.requireLocalization("dojo.cldr", "gregorian", null, "zh-cn,zh,en-ca,ko-kr,pt,pt-br,it-it,ROOT,en-gb,de,ja,en,en-au,fr,es,ko,zh-tw,it,es-es");

    //NOTE: Everything in this module assumes Gregorian calendars.
    // Other calendars will be implemented in separate modules.

    (function() {
        // Format a pattern without literals
        function formatPattern(dateObject, bundle, fullYear, pattern) {
            return pattern.replace(/([a-z])\1*/ig, function(match) {
                var s, pad;
                var c = match.charAt(0);
                var l = match.length;
                var widthList = ["abbr", "wide", "narrow"];
                switch (c) {
                    case 'G':
                        s =
                        bundle[(l < 4) ? "eraAbbr" : "eraNames"][dateObject.getFullYear() < 0 ? 0 :
                                                                 1];
                        break;
                    case 'y':
                        s = dateObject.getFullYear();
                        switch (l) {
                            case 1:
                                break;
                            case 2:
                                if (!fullYear) {
                                    s = String(s);
                                    s = s.substr(s.length - 2);
                                    break;
                                }
                            // fallthrough
                            default:
                                pad = true;
                        }
                        break;
                    case 'Q':
                    case 'q':
                        s = Math.ceil((dateObject.getMonth() + 1) / 3);
                    //					switch(l){
                    //						case 1: case 2:
                        pad = true;
                    //							break;
                    //						case 3: case 4: // unimplemented
                    //					}
                        break;
                    case 'M':
                    case 'L':
                        var m = dateObject.getMonth();
                        var widthM;
                        switch (l) {
                            case 1: case 2:
                            s = m + 1; pad = true;
                            break;
                            case 3: case 4: case 5:
                            widthM = widthList[l - 3];
                            break;
                        }
                        if (widthM) {
                            var typeM = (c == "L") ? "standalone" : "format";
                            var propM = ["months", typeM, widthM].join("-");
                            s = bundle[propM][m];
                        }
                        break;
                    case 'w':
                        var firstDay = 0;
                        s = dojo.date.locale._getWeekOfYear(dateObject, firstDay); pad = true;
                        break;
                    case 'd':
                        s = dateObject.getDate(); pad = true;
                        break;
                    case 'D':
                        s = dojo.date.locale._getDayOfYear(dateObject); pad = true;
                        break;
                    case 'E':
                    case 'e':
                    case 'c': // REVIEW: don't see this in the spec?
                        var d = dateObject.getDay();
                        var widthD;
                        switch (l) {
                            case 1: case 2:
                            if (c == 'e') {
                                var first = dojo.cldr.supplemental.getFirstDayOfWeek(options.locale);
                                d = (d - first + 7) % 7;
                            }
                            if (c != 'c') {
                                s = d + 1;
                                pad = true;
                                break;
                            }
                            // else fallthrough...
                            case 3: case 4: case 5:
                            widthD = widthList[l - 3];
                            break;
                        }
                        if (widthD) {
                            var typeD = (c == "c") ? "standalone" : "format";
                            var propD = ["days", typeD, widthD].join("-");
                            s = bundle[propD][d];
                        }
                        break;
                    case 'a':
                        var timePeriod = (dateObject.getHours() < 12) ? 'am' : 'pm';
                        s = bundle[timePeriod];
                        break;
                    case 'h':
                    case 'H':
                    case 'K':
                    case 'k':
                        var h = dateObject.getHours();
                    // strange choices in the date format make it impossible to write this succinctly
                        switch (c) {
                            case 'h': // 1-12
                                s = (h % 12) || 12;
                                break;
                            case 'H': // 0-23
                                s = h;
                                break;
                            case 'K': // 0-11
                                s = (h % 12);
                                break;
                            case 'k': // 1-24
                                s = h || 24;
                                break;
                        }
                        pad = true;
                        break;
                    case 'm':
                        s = dateObject.getMinutes(); pad = true;
                        break;
                    case 's':
                        s = dateObject.getSeconds(); pad = true;
                        break;
                    case 'S':
                        s = Math.round(dateObject.getMilliseconds() * Math.pow(10, l - 3)); pad =
                                                                                            true;
                        break;
                    case 'v': // FIXME: don't know what this is. seems to be same as z?
                    case 'z':
                    // We only have one timezone to offer; the one from the browser
                        s = dojo.date.getTimezoneName(dateObject);
                        if (s) {
                            break;
                        }
                        l = 4;
                    // fallthrough... use GMT if tz not available
                    case 'Z':
                        var offset = dateObject.getTimezoneOffset();
                        var tz = [
                            (offset <= 0 ? "+" : "-"),
                            dojo.string.pad(Math.floor(Math.abs(offset) / 60), 2),
                            dojo.string.pad(Math.abs(offset) % 60, 2)
                        ];
                        if (l == 4) {
                            tz.splice(0, 0, "GMT");
                            tz.splice(3, 0, ":");
                        }
                        s = tz.join("");
                        break;
                    //				case 'Y': case 'u': case 'W': case 'F': case 'g': case 'A':
                    //					console.debug(match+" modifier unimplemented");
                    default:
                        throw new Error("dojo.date.locale.format: invalid pattern char: " +
                                        pattern);
                }
                if (pad) {
                    s = dojo.string.pad(s, l);
                }
                return s;
            });
        }

        /*=====
         dojo.date.locale.__FormatOptions = function(){
         //	selector: String
         //		choice of 'time','date' (default: date and time)
         //	formatLength: String
         //		choice of long, short, medium or full (plus any custom additions).  Defaults to 'short'
         //	datePattern:String
         //		override pattern with this string
         //	timePattern:String
         //		override pattern with this string
         //	am: String
         //		override strings for am in times
         //	pm: String
         //		override strings for pm in times
         //	locale: String
         //		override the locale used to determine formatting rules
         //	fullYear: Boolean
         //		(format only) use 4 digit years whenever 2 digit years are called for
         //	strict: Boolean
         //		(parse only) strict parsing, off by default
         this.selector = selector;
         this.formatLength = formatLength;
         this.datePattern = datePattern;
         this.timePattern = timePattern;
         this.am = am;
         this.pm = pm;
         this.locale = locale;
         this.fullYear = fullYear;
         this.strict = strict;
         }
         =====*/

        dojo.date.locale.format =
        function(/*Date*/dateObject, /*dojo.date.locale.__FormatOptions?*/options) {
            // summary:
            //		Format a Date object as a String, using locale-specific settings.
            //
            // description:
            //		Create a string from a Date object using a known localized pattern.
            //		By default, this method formats both date and time from dateObject.
            //		Formatting patterns are chosen appropriate to the locale.  Different
            //		formatting lengths may be chosen, with "full" used by default.
            //		Custom patterns may be used or registered with translations using
            //		the dojo.date.locale.addCustomFormats method.
            //		Formatting patterns are implemented using [the syntax described at
            //		unicode.org](http://www.unicode.org/reports/tr35/tr35-4.html#Date_Format_Patterns)
            //
            // dateObject:
            //		the date and/or time to be formatted.  If a time only is formatted,
            //		the values in the year, month, and day fields are irrelevant.  The
            //		opposite is true when formatting only dates.

            options = options || {};

            var locale = dojo.i18n.normalizeLocale(options.locale);
            var formatLength = options.formatLength || 'short';
            var bundle = dojo.date.locale._getGregorianBundle(locale);
            var str = [];
            var sauce = dojo.hitch(this, formatPattern, dateObject, bundle, options.fullYear);
            if (options.selector == "year") {
                // Special case as this is not yet driven by CLDR data
                var year = dateObject.getFullYear();
                if (locale.match(/^zh|^ja/)) {
                    year += "\u5E74";
                }
                return year;
            }
            if (options.selector != "time") {
                var datePattern = options.datePattern || bundle["dateFormat-" + formatLength];
                if (datePattern) {
                    str.push(_processPattern(datePattern, sauce));
                }
            }
            if (options.selector != "date") {
                var timePattern = options.timePattern || bundle["timeFormat-" + formatLength];
                if (timePattern) {
                    str.push(_processPattern(timePattern, sauce));
                }
            }
            var result = str.join(" "); //TODO: use locale-specific pattern to assemble date + time
            return result; // String
        };

        dojo.date.locale.regexp = function(/*dojo.date.locale.__FormatOptions?*/options) {
            // summary:
            //		Builds the regular needed to parse a localized date

            return dojo.date.locale._parseInfo(options).regexp; // String
        };

        dojo.date.locale._parseInfo = function(/*dojo.date.locale.__FormatOptions?*/options) {
            options = options || {};
            var locale = dojo.i18n.normalizeLocale(options.locale);
            var bundle = dojo.date.locale._getGregorianBundle(locale);
            var formatLength = options.formatLength || 'short';
            var datePattern = options.datePattern || bundle["dateFormat-" + formatLength];
            var timePattern = options.timePattern || bundle["timeFormat-" + formatLength];
            var pattern;
            if (options.selector == 'date') {
                pattern = datePattern;
            } else if (options.selector == 'time') {
                pattern = timePattern;
            } else {
                pattern = datePattern + ' ' + timePattern; //TODO: use locale-specific pattern to assemble date + time
            }

            var tokens = [];
            var re = _processPattern(pattern, dojo.hitch(this, _buildDateTimeRE, tokens, bundle, options));
            return {regexp: re, tokens: tokens, bundle: bundle};
        };

        dojo.date.locale.parse =
        function(/*String*/value, /*dojo.date.locale.__FormatOptions?*/options) {
            // summary:
            //		Convert a properly formatted string to a primitive Date object,
            //		using locale-specific settings.
            //
            // description:
            //		Create a Date object from a string using a known localized pattern.
            //		By default, this method parses looking for both date and time in the string.
            //		Formatting patterns are chosen appropriate to the locale.  Different
            //		formatting lengths may be chosen, with "full" used by default.
            //		Custom patterns may be used or registered with translations using
            //		the dojo.date.locale.addCustomFormats method.
            //
            //		Formatting patterns are implemented using [the syntax described at
            //		unicode.org](http://www.unicode.org/reports/tr35/tr35-4.html#Date_Format_Patterns)
            //		When two digit years are used, a century is chosen according to a sliding
            //		window of 80 years before and 20 years after present year, for both `yy` and `yyyy` patterns.
            //		year < 100CE requires strict mode.
            //
            // value:
            //		A string representation of a date

            var info = dojo.date.locale._parseInfo(options);
            var tokens = info.tokens, bundle = info.bundle;
            var re = new RegExp("^" + info.regexp + "$");
            var match = re.exec(value);
            if (!match) {
                return null;
            } // null

            var widthList = ['abbr', 'wide', 'narrow'];
            var result = [1970,0,1,0,0,0,0]; // will get converted to a Date at the end
            var amPm = "";
            var valid = dojo.every(match, function(v, i) {
                if (!i) {
                    return true;
                }
                var token = tokens[i - 1];
                var l = token.length;
                switch (token.charAt(0)) {
                    case 'y':
                        if (l != 2 && options.strict) {
                            //interpret year literally, so '5' would be 5 A.D.
                            result[0] = v;
                        } else {
                            if (v < 100) {
                                v = Number(v);
                                //choose century to apply, according to a sliding window
                                //of 80 years before and 20 years after present year
                                var year = '' + new Date().getFullYear();
                                var century = year.substring(0, 2) * 100;
                                var cutoff = Math.min(Number(year.substring(2, 4)) + 20, 99);
                                var num = (v < cutoff) ? century + v : century - 100 + v;
                                result[0] = num;
                            } else {
                                //we expected 2 digits and got more...
                                if (options.strict) {
                                    return false;
                                }
                                //interpret literally, so '150' would be 150 A.D.
                                //also tolerate '1950', if 'yyyy' input passed to 'yy' format
                                result[0] = v;
                            }
                        }
                        break;
                    case 'M':
                        if (l > 2) {
                            var months = bundle['months-format-' + widthList[l - 3]].concat();
                            if (!options.strict) {
                                //Tolerate abbreviating period in month part
                                //Case-insensitive comparison
                                v = v.replace(".", "").toLowerCase();
                                months = dojo.map(months, function(s) {
                                    return s.replace(".", "").toLowerCase();
                                });
                            }
                            v = dojo.indexOf(months, v);
                            if (v == -1) {
                                //						console.debug("dojo.date.locale.parse: Could not parse month name: '" + v + "'.");
                                return false;
                            }
                        } else {
                            v--;
                        }
                        result[1] = v;
                        break;
                    case 'E':
                    case 'e':
                        var days = bundle['days-format-' + widthList[l - 3]].concat();
                        if (!options.strict) {
                            //Case-insensitive comparison
                            v = v.toLowerCase();
                            days = dojo.map(days, function(d) {
                                return d.toLowerCase();
                            });
                        }
                        v = dojo.indexOf(days, v);
                        if (v == -1) {
                            //					console.debug("dojo.date.locale.parse: Could not parse weekday name: '" + v + "'.");
                            return false;
                        }

                    //TODO: not sure what to actually do with this input,
                    //in terms of setting something on the Date obj...?
                    //without more context, can't affect the actual date
                    //TODO: just validate?
                        break;
                    case 'D':
                        result[1] = 0;
                    // fallthrough...
                    case 'd':
                        result[2] = v;
                        break;
                    case 'a': //am/pm
                        var am = options.am || bundle.am;
                        var pm = options.pm || bundle.pm;
                        if (!options.strict) {
                            var period = /\./g;
                            v = v.replace(period, '').toLowerCase();
                            am = am.replace(period, '').toLowerCase();
                            pm = pm.replace(period, '').toLowerCase();
                        }
                        if (options.strict && v != am && v != pm) {
                            //					console.debug("dojo.date.locale.parse: Could not parse am/pm part.");
                            return false;
                        }

                    // we might not have seen the hours field yet, so store the state and apply hour change later
                        amPm = (v == pm) ? 'p' : (v == am) ? 'a' : '';
                        break;
                    case 'K': //hour (1-24)
                        if (v == 24) {
                            v = 0;
                        }
                    // fallthrough...
                    case 'h': //hour (1-12)
                    case 'H': //hour (0-23)
                    case 'k': //hour (0-11)
                    //TODO: strict bounds checking, padding
                        if (v > 23) {
                            //					console.debug("dojo.date.locale.parse: Illegal hours value");
                            return false;
                        }

                    //in the 12-hour case, adjusting for am/pm requires the 'a' part
                    //which could come before or after the hour, so we will adjust later
                        result[3] = v;
                        break;
                    case 'm': //minutes
                        result[4] = v;
                        break;
                    case 's': //seconds
                        result[5] = v;
                        break;
                    case 'S': //milliseconds
                        result[6] = v;
                    //				break;
                    //			case 'w':
                    //TODO				var firstDay = 0;
                    //			default:
                    //TODO: throw?
                    //				console.debug("dojo.date.locale.parse: unsupported pattern char=" + token.charAt(0));
                }
                return true;
            });

            var hours = +result[3];
            if (amPm === 'p' && hours < 12) {
                result[3] = hours + 12; //e.g., 3pm -> 15
            } else if (amPm === 'a' && hours == 12) {
                result[3] = 0; //12am -> 0
            }

            //TODO: implement a getWeekday() method in order to test
            //validity of input strings containing 'EEE' or 'EEEE'...

            var dateObject = new Date(result[0], result[1], result[2], result[3], result[4], result[5], result[6]); // Date
            if (options.strict) {
                dateObject.setFullYear(result[0]);
            }

            // Check for overflow.  The Date() constructor normalizes things like April 32nd...
            //TODO: why isn't this done for times as well?
            var allTokens = tokens.join("");
            if (!valid ||
                (allTokens.indexOf('M') != -1 && dateObject.getMonth() != result[1]) ||
                (allTokens.indexOf('d') != -1 && dateObject.getDate() != result[2])) {
                return null;
            }

            return dateObject; // Date
        };

        function _processPattern(pattern, applyPattern, applyLiteral, applyAll) {
            //summary: Process a pattern with literals in it

            // Break up on single quotes, treat every other one as a literal, except '' which becomes '
            var identity = function(x) {
                return x;
            };
            applyPattern = applyPattern || identity;
            applyLiteral = applyLiteral || identity;
            applyAll = applyAll || identity;

            //split on single quotes (which escape literals in date format strings)
            //but preserve escaped single quotes (e.g., o''clock)
            var chunks = pattern.match(/(''|[^'])+/g);
            var literal = false;

            dojo.forEach(chunks, function(chunk, i) {
                if (!chunk) {
                    chunks[i] = '';
                } else {
                    chunks[i] = (literal ? applyLiteral : applyPattern)(chunk);
                    literal = !literal;
                }
            });
            return applyAll(chunks.join(''));
        }

        function _buildDateTimeRE(tokens, bundle, options, pattern) {
            pattern = dojo.regexp.escapeString(pattern);
            if (!options.strict) {
                pattern = pattern.replace(" a", " ?a");
            } // kludge to tolerate no space before am/pm
            return pattern.replace(/([a-z])\1*/ig, function(match) {
                // Build a simple regexp.  Avoid captures, which would ruin the tokens list
                var s;
                var c = match.charAt(0);
                var l = match.length;
                var p2 = '', p3 = '';
                if (options.strict) {
                    if (l > 1) {
                        p2 = '0' + '{' + (l - 1) + '}';
                    }
                    if (l > 2) {
                        p3 = '0' + '{' + (l - 2) + '}';
                    }
                } else {
                    p2 = '0?';
                    p3 = '0{0,2}';
                }
                switch (c) {
                    case 'y':
                        s = '\\d{2,4}';
                        break;
                    case 'M':
                        s = (l > 2) ? '\\S+' : p2 + '[1-9]|1[0-2]';
                        break;
                    case 'D':
                        s = p2 + '[1-9]|' + p3 + '[1-9][0-9]|[12][0-9][0-9]|3[0-5][0-9]|36[0-6]';
                        break;
                    case 'd':
                        s = p2 + '[1-9]|[12]\\d|3[01]';
                        break;
                    case 'w':
                        s = p2 + '[1-9]|[1-4][0-9]|5[0-3]';
                        break;
                    case 'E':
                        s = '\\S+';
                        break;
                    case 'h': //hour (1-12)
                        s = p2 + '[1-9]|1[0-2]';
                        break;
                    case 'k': //hour (0-11)
                        s = p2 + '\\d|1[01]';
                        break;
                    case 'H': //hour (0-23)
                        s = p2 + '\\d|1\\d|2[0-3]';
                        break;
                    case 'K': //hour (1-24)
                        s = p2 + '[1-9]|1\\d|2[0-4]';
                        break;
                    case 'm':
                    case 's':
                        s = '[0-5]\\d';
                        break;
                    case 'S':
                        s = '\\d{' + l + '}';
                        break;
                    case 'a':
                        var am = options.am || bundle.am || 'AM';
                        var pm = options.pm || bundle.pm || 'PM';
                        if (options.strict) {
                            s = am + '|' + pm;
                        } else {
                            s = am + '|' + pm;
                            if (am != am.toLowerCase()) {
                                s += '|' + am.toLowerCase();
                            }
                            if (pm != pm.toLowerCase()) {
                                s += '|' + pm.toLowerCase();
                            }
                        }
                        break;
                    default:
                    // case 'v':
                    // case 'z':
                    // case 'Z':
                        s = ".*";
                    //				console.debug("parse of date format, pattern=" + pattern);
                }

                if (tokens) {
                    tokens.push(match);
                }

                return "(" + s + ")"; // add capture
            }).replace(/[\xa0 ]/g, "[\\s\\xa0]"); // normalize whitespace.  Need explicit handling of \xa0 for IE.
        }
    })();

    (function() {
        var _customFormats = [];
        dojo.date.locale.addCustomFormats = function(/*String*/packageName, /*String*/bundleName) {
            // summary:
            //		Add a reference to a bundle containing localized custom formats to be
            //		used by date/time formatting and parsing routines.
            //
            // description:
            //		The user may add custom localized formats where the bundle has properties following the
            //		same naming convention used by dojo.cldr: `dateFormat-xxxx` / `timeFormat-xxxx`
            //		The pattern string should match the format used by the CLDR.
            //		See dojo.date.locale.format() for details.
            //		The resources must be loaded by dojo.requireLocalization() prior to use

            _customFormats.push({pkg:packageName,name:bundleName});
        };

        dojo.date.locale._getGregorianBundle = function(/*String*/locale) {
            var gregorian = {};
            dojo.forEach(_customFormats, function(desc) {
                var bundle = dojo.i18n.getLocalization(desc.pkg, desc.name, locale);
                gregorian = dojo.mixin(gregorian, bundle);
            }, this);
            return gregorian;
            /*Object*/
        };
    })();

    dojo.date.locale.addCustomFormats("dojo.cldr", "gregorian");

    dojo.date.locale.getNames =
    function(/*String*/item, /*String*/type, /*String?*/use, /*String?*/locale) {
        // summary:
        //		Used to get localized strings from dojo.cldr for day or month names.
        //
        // item:
        //	'months' || 'days'
        // type:
        //	'wide' || 'narrow' || 'abbr' (e.g. "Monday", "Mon", or "M" respectively, in English)
        // use:
        //	'standAlone' || 'format' (default)
        // locale:
        //	override locale used to find the names

        var label;
        var lookup = dojo.date.locale._getGregorianBundle(locale);
        var props = [item, use, type];
        if (use == 'standAlone') {
            label = lookup[props.join('-')];
        }
        props[1] = 'format';

        // return by copy so changes won't be made accidentally to the in-memory model
        return (label || lookup[props.join('-')]).concat();
        /*Array*/
    };

    dojo.date.locale.isWeekend = function(/*Date?*/dateObject, /*String?*/locale) {
        // summary:
        //	Determines if the date falls on a weekend, according to local custom.

        var weekend = dojo.cldr.supplemental.getWeekend(locale);
        var day = (dateObject || new Date()).getDay();
        if (weekend.end < weekend.start) {
            weekend.end += 7;
            if (day < weekend.start) {
                day += 7;
            }
        }
        return day >= weekend.start && day <= weekend.end; // Boolean
    };

    // These are used only by format and strftime.  Do they need to be public?  Which module should they go in?

    dojo.date.locale._getDayOfYear = function(/*Date*/dateObject) {
        // summary: gets the day of the year as represented by dateObject
        return dojo.date.difference(new Date(dateObject.getFullYear(), 0, 1), dateObject) + 1; // Number
    };

    dojo.date.locale._getWeekOfYear = function(/*Date*/dateObject, /*Number*/firstDayOfWeek) {
        if (arguments.length == 1) {
            firstDayOfWeek = 0;
        } // Sunday

        var firstDayOfYear = new Date(dateObject.getFullYear(), 0, 1).getDay();
        var adj = (firstDayOfYear - firstDayOfWeek + 7) % 7;
        var week = Math.floor((dojo.date.locale._getDayOfYear(dateObject) + adj - 1) / 7);

        // if year starts on the specified day, start counting weeks at 1
        if (firstDayOfYear == firstDayOfWeek) {
            week++;
        }

        return week; // Number
    };

}
